package com.sitech.ibnms.util;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

/**
 * 处理时间的类
 * 周六和周日的时间不算.有效计算时间范围是周一~周五的09:00~18:00.
 * 外部使用接口：public Date handlerDates(Date date, double interval)
 * 参数说明：date   基准时间
 *         interval 时间间隔，单位：小时（可以是小数）
 * @author Administrator
 *
 */

public class TimeHandler {
	
	/**
	 * 
	 * 根据时间间隔，在当前系统时间的基础上，计算时间间隔之后的时间
	 * 不区分工作时间
	 * @param intervalTime  单位为分钟
	 * @return
	 */
	public static String calDate(String intervalTime){
		String strRet="";
		Date dCurrDate = new Date();
		Calendar   insCalendar   =   new   GregorianCalendar();   
		insCalendar.setTime(dCurrDate);  //得到当前的日历时间
		
		int iCurrValue=insCalendar.get(Calendar.MINUTE);
		insCalendar.set(Calendar.MINUTE,iCurrValue+Integer.parseInt(intervalTime));
		
		try {
			strRet=DateFormater.datetimeToString(insCalendar.getTime());
		} catch (ParseException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		}
		
		return strRet;
	}
	
	/**
	 * 返回标准格式的字符串类型
	 * 
	 * @param date
	 * @param interval
	 * @return
	 */
	public static String handlerDatesOfStr(Date date,double interval){
		try {
			return DateFormater.datetimeToString(handlerDates(date,interval));
		} catch (ParseException e) {
			// TODO 自动生成 catch 块			
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 处理时间的方法，要求是5*8小时工作制，并周六和周日的时间不算.有效计算时间范围是周一~周五的09:00~18:00.
	 * 时间相加要在有效的时间里相加。例如：2008-09-05 20:00：00它不算是有效时间，因为它是周周五，并且时间是>18:00,计算
	 * 它的有效时间是在2008-09-08 09:00:00这个时间再加上interval时间.并继续计算相加的时间是不是在有效的时间里。
	 * 
	 * @param date
	 *            要处理的时间
	 * @param interval
	 *            间隔时间,可以带小数点
	 * @return 在有效的时间里相加的结果
	 */
	public static Date handlerDates(Date date, double interval) {
		if (interval == 0) {
			return date;
		}

		date = new Date(doHandlerholiday(date));

		Calendar cal = Calendar.getInstance();
		cal.setTime(date);

		long current_total_time = date.getTime();
		int hours_time = cal.get(Calendar.HOUR_OF_DAY);
		int minite_time = cal.get(Calendar.MINUTE);
		int seconds = cal.get(Calendar.SECOND);
		// 间隔多少个工作日
		long comple_day = Math.round(interval) / 9;
		// 剩下时间
		double comple_hour = 0;
		comple_hour = interval % 9;

		// d_time+=comple_day;
		// 当前几周时间
		long cd = comple_day / 5;

		// 几周之后还剩几天
		long remaing_day = comple_day % 5;

		// 当前时间距离下午18：00的时间curent_hour = 18-现在的时间
		double curent_hour = (18 * 3600 * 1000D - hours_time * 3600 * 1000D - minite_time * 60 * 1000D - seconds * 1000D) / (3600 * 1000D);
		double doTime = dohandlerTime(curent_hour, comple_hour);

		// 处理在相加完时间间隔后是否超过了18：00点，如果超过加一天
		// doTime=-的才有意义，因为-的说明当前的时间超出要在第二天的有效时间内才算。如果 是正的话。说明可以满足当天时间要求
		if (doTime < 0) {
			remaing_day += 1;
			if (Math.round(remaing_day) / 5 > 0) {
				cd += 1;
				remaing_day = 0;
			}

		}

		// 处理总时间
		current_total_time = new Double(current_total_time + cd * 7 * 24 * 60 * 60 * 1000L).longValue();
		cal.setTime(new Date(current_total_time));

		int beforeday = cal.get(Calendar.DAY_OF_WEEK);

		double countday = beforeday + remaing_day;
		if (countday == 7) {
			remaing_day += 1;
		} else if (countday == 8) {
			remaing_day += 2;
		} else if (countday == 9) {
			remaing_day += 3;
		}

		// 这个时间要考虑周六的问题,如果是周末的话,要加+的
		current_total_time += remaing_day * 24 * 60 * 60 * 1000L;
		// 把计算后的时间再进行处理，看是否是周六或无效的时间
		current_total_time = doHandlerholiday(new Date(current_total_time));

		// //这次要考虑时间的问题
		if (doTime < 0) {
			// System.out.println("doTime<0******" + doTime);
			doTime = Math.abs(doTime);
			comple_hour = 0;
			current_total_time = handleTimeToSecondDay(new Date(current_total_time));// 处理成第二天的9：00的时间
		} else {
			doTime = 0;
		}

		// 总时间=讲算后的时间+（一种是09：00后的时间||一种是当前可满足的时间）********这个时间有问题**********
		current_total_time += doTime * 3600 * 1000L + comple_hour * 3600 * 1000L;
		return new Date(current_total_time);
	}

	/**
	 * 处理周六和周日的情况,如果是周六的话那么时间就是下周一的09：00如果是周日的话时间+2，时间也是下周一的09：00,否则时间不变还是当前处理的时间
	 * 
	 * @param date
	 *            要处理的时间
	 * @return 处理后的时间
	 */
	public static long doHandlerholiday(Date date) {

		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		long current_total_time = date.getTime();
		int day_time = cal.get(Calendar.DAY_OF_WEEK);
		int hours_time = cal.get(Calendar.HOUR_OF_DAY);
		int minite_time = cal.get(Calendar.MINUTE);
		int seconds = cal.get(Calendar.SECOND);

		long addTime = 0;
		if (day_time == 7 || day_time == 1) {
			if (day_time == 7) {
				addTime = 2 * 24 * 60 * 60 * 1000L;
			} else {
				addTime = 1 * 24 * 60 * 60 * 1000L;
			}
			current_total_time = current_total_time + addTime - handlerHour(hours_time, minite_time, seconds);
		} else if (hours_time >= 18) {
			current_total_time += 24 * 60 * 60 * 1000L - handlerHour(hours_time, minite_time, seconds);
		}
		cal.setTime(new Date(current_total_time));
		day_time = cal.get(Calendar.DAY_OF_WEEK);

		if (day_time != 7 && day_time != 1) {
			return current_total_time;
		} else {
			return doHandlerholiday(cal.getTime());
		}

	}

	/**
	 * 把固定的时间处理成第二天的09：00:00
	 * 
	 * @param date
	 *            当前的时间
	 * @return 返回处理后的第二天09:00:00的时间
	 */
	public static long handleTimeToSecondDay(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		long current_total_time = date.getTime();
		int hours_time = cal.get(Calendar.HOUR_OF_DAY);
		int minite_time = cal.get(Calendar.MINUTE);
		int seconds = cal.get(Calendar.SECOND);

		current_total_time -= handlerHour(hours_time, minite_time, seconds);

		return current_total_time;
	}

	/**
	 * 处理差值的时间，这个时间如果>=0，时间加一天，否则不用加,它可以在这个时间区域(09:00~18:00)里。
	 * 
	 * @param lesshour
	 *            当前时间距离18：00的这个差值时间
	 * @param interval
	 *            相加的间隔时间
	 * @return
	 */
	public static double dohandlerTime(double lesshour, double interval) {

		double less_time = lesshour - interval;

		return less_time;
	}

	/**
	 * 处理时间时与interval相加得到一个时间，考虑到5*8时间的限制
	 * 
	 * @param date
	 *            处理的时间
	 * @param interval
	 *            时间间隔
	 * @return 处理后的时间
	 */
	public static Date handlerDate(Date date, int interval) {
		if (date == null) {
			return null;
		}
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);

		int day_time = cal.get(Calendar.DAY_OF_WEEK);

		int hours_time = cal.get(Calendar.HOUR_OF_DAY);
		int minite_time = cal.get(Calendar.MINUTE);
		int seconds = cal.get(Calendar.SECOND);

		long time = date.getTime();
		long addTime = 0;
		if (day_time == 7 || day_time == 1) {
			time = handlerDay(time, day_time, addTime, hours_time, minite_time, seconds, interval);
			return new Date(time);
		}
		// 2008-09-04 09:00:00
		if (hours_time > 18 || hours_time < 9) {
			time = handlerHours(time, day_time, addTime, hours_time, minite_time, seconds, interval);
			return new Date(time);
		}

		time += interval * 60 * 60 * 1000L;
		Date n_d1 = new Date(time);
		Calendar c1 = Calendar.getInstance();
		int day = c1.get(Calendar.DAY_OF_WEEK);
		int hour = c1.get(Calendar.HOUR_OF_DAY);
		if (day == 7 || day == 1) {
			if (hour > 18) {

			}
			return handlerDate(n_d1, interval);
		}
		return new Date(time);
	}

	/**
	 * 处理小时的，现在时刻距离09：00:00的差值
	 * 
	 * @param hour
	 * @return
	 */
	public static long handlerHour(int hour, int minite, int seconds) {
		return ((hour * 60 + minite) * 60 * 1000L + seconds * 1000L) - (9 * 60 * 60 * 1000L);
	}

	/**
	 * 考虑周六和周日的情况。
	 * 
	 * @param time
	 * @param day_time
	 * @param addTime
	 * @param hours_time
	 * @param minite_time
	 * @param seconds
	 * @param interval
	 * @return
	 */
	public static long handlerDay(long time, int day_time, long addTime, int hours_time, int minite_time, int seconds, int interval) {
		if (day_time == 7) {
			addTime = 2 * 24 * 60 * 60 * 1000L;
		} else {
			addTime = 1 * 24 * 60 * 60 * 1000L;
		}

		time += addTime;
		time = time - handlerHour(hours_time, minite_time, seconds) + interval * 60 * 60 * 1000L;
		return time;
	}

	/**
	 * 处理小于早晨9点，大于18点的时间处理
	 * 
	 * @param time
	 * @param day_time
	 * @param addTime
	 * @param hours_time
	 * @param minite_time
	 * @param seconds
	 * @param interval
	 * @return
	 */
	public static long handlerHours(long time, int day_time, long addTime, int hours_time, int minite_time, int seconds, int interval) {
		if (hours_time > 18) {
			addTime = 1 * 24 * 60 * 60 * 1000L;
		} else {
			addTime = 0;
		}
		time += addTime;
		time = time - handlerHour(hours_time, minite_time, seconds) + interval * 60 * 60 * 1000L;
		return time;
	}
	
	public static List<String> getDateArray(Date date ,int interval){
		List<String> dateArray = new ArrayList<String>();
		while(true){
			dateArray.add(getForwardTime(date, interval).substring(5, 10));
			interval -- ;
			if(interval == -1){
				break;
			}
		}
		return dateArray;
	}
	
	public static String getForwardTime(Date date, int interval) {
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		long time = date.getTime() - interval * 60 * 60 * 1000 * 24;
		Date strdate = new Date(time);
		return formatter.format(strdate);
	}

	
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		List<String> array = getDateArray(new Date(), 6);
		for(String d:array){
			System.out.println(d);
		}
		// TODO Auto-generated method stub		
		/*Date dd1 = TimeHandler.handlerDates(new Date(), 4.5);
		Date dd = TimeHandler.handlerDates(new Date(), 102.999);
		
		System.out.println("dd1 = "+dd1.toLocaleString());
		System.out.println("dd = "+dd.toLocaleString());*/

	}
}
